---
markmap:
  colorFreezeLevel: 3
  maxWidth: 350
  initialExpandLevel: 2
  coloring: branch
  titleAsRootNode: false
---
# Individual Project
- Learning Outcome 1 - Analysing
	- Attend Workshops
		- Week 1: Building Foundations in Analysis and Design
		- How can functional requirements be expressed as use cases and a conceptual model?
	- Create Project Ideation
		- Idea Description
			- Choose a topic for your application. Start by picking a subject you know something about.
			- Identify a problem that your software can solve or a purpose that your software can fulfil.
			- Determine the complexity
				- Define multiple requirements for your application.
				- Store and manage data using a database.
				- Incorporate multiple entities (e.g., users, items, events).
		- Poster
	- Get Ideation Approval
	- Explore Your Idea Fully (Apply Research When Needed)
	- Research Technology Stack
		- Options
			- ASP.NET MVC
			- ASP.NET Razor Pages
			- Other Viable Alternative Technology Stack
				- Allows for Demonstrating Learning Outcomes
				- Requires Teacher Approval
		- Static Web Content (CSS, JS, images, ...)
		- Frontend  Layout(s) & Views
		- Code behind & Data Binding
		- Url Addressing of Views
		- Handling of GET/POST/DELETE/UPDATE requests
		- ...
	- Create User Requirements Specification
		- Determine User Requirements
			- Functional
			- Non Functional
			- Apply Priorities (MoSCoW)
		- Determine Use Cases
			- Consider Actor, Preconditions, Postconditions
			- Describe Main Scenario
			- Describe Extensions When Applicable
	- Create Conceptual Data Model
		 - Research Data Model Types
			 - Conceptual
			 - Logical
			 - Physical
		- Explore Design Tools for Data Model
			- [Lucidchart](https://lucidchart.com)
			- [app.diagrams.net](https://app.diagrams.net)
			- [Mermaid](https://mermaid.live)
			- [Visual Paradigm](https://www.visual-paradigm.com/)
			- ... any new design tool available 😎
		- Choose Design Notation Style
			- Chen (as shown in Canvas)
			- Crow's Foot
		- Determine Required Entities
		- Determine Entity Attributes
		- Determine Entity Relationships
	- Create Acceptance Test Plan
		- Determine validation steps for each requirement
		- Determine data to be used for validation
		- Describe the expected outcome
	- Document Your Work
		- Project Analysis (ideation + research + technology)
		- User Requirements Specification
		- Conceptual Data Model
		- Acceptance Test Plan
- Learning Outcome 2 - Designing
	- Explore How Design Connects to Analysis
	- Attend Workshops
		- Week 1: Building Foundations in Analysis and Design
		- How to go from a conceptual diagram to concrete diagrams for implementation purposes?
		- How to ensure the functional requirements are implemented as agreed?
		- How to start designing maintainable code?
		- How can SOLID help with designing maintainable code?
		- How do anemic models compare to rich models?	
	- Research Design Types
		- Wireframes
		- Paper Prototype / Lo-Hi Fidelity Design (optional)
		- Database Design (ERD)
		- Flowchart(s)
		- [C4 model](https://c4model.com/)
			- Level 1: Software system. A software system is the highest level of abstraction and describes something that delivers value to its users, whether they are human or not.
			- Level 2: Container. A container represents an application or a data store. A container is something that needs to be running in order for the overall software system to work. A container is essentially a runtime boundary around some code that is being executed or some data that is being stored.
			- Level 3: Component. A component is a grouping of related functionality encapsulated behind a well-defined interface. If you’re using a language like Java or C#, the simplest way to think of a component is that it’s a collection of implementation classes behind an interface. With the C4 model, components are _not_ separately deployable units. Instead, it’s the container that’s the deployable unit.
		- UML Class Diagram
		- Activity Diagram
	- Explore Design Tools
		- [Figma](https://www.figma.com)
		- [Canva](https://www.canva.com/en_gb/)
		- [drawSQL](https://drawsql.app)
		- [Mermaid](https://mermaid.live)
		- [app.diagrams.net](https://app.diagrams.net)
		- [Mermaid](https://mermaid.live)
		- [Visual Paradigm](https://www.visual-paradigm.com/)
		- [UMLet(ino)](https://umletino.com)
		- ... any new design tool available 😎
	- Create Wireframes
		- - 🧱 Core Structural Elements
			- Layout Grid – Establishes consistent alignment and spacing across the wireframe.
			- Page Structure – Defines main areas such as header, footer, sidebar, and content sections.
			- Hierarchy – Visually distinguishes primary vs. secondary elements using size, position, and grouping.
		- 🧭 Navigation Elements
			- Navigation Menus – Top nav, side nav, hamburger menu, etc., with labeled placeholders.
			- Breadcrumbs / Back Links – For user orientation and easy movement between sections.
		- ⚙️ Functional Components
			- Placeholders for UI Elements – Buttons, forms, sliders, cards, modals, etc., clearly marked (often with "X"s or labels).
			- Interaction Hints – Notes or icons showing expected behaviors (e.g., dropdowns, hover states, collapsible panels).
		- 🗺️ User Flow & Intent
			- Call-to-Actions (CTAs) – Highlighted clearly to show primary user goals on the page.
			- Content Priority – Placement indicates what's most important to users (e.g., hero area, feature list).
			- Scenario-based Logic – Includes variations or branches to represent user choices or states (e.g., logged in vs. guest).
		- 📝 Annotations & Notes
			- Labels on Elements – Use descriptive text (e.g., "Search bar", "Product image", "Filter options") instead of dummy content.
			- Developer Notes or Comments – Explain functionality, rules, or API needs (e.g., "This form auto-saves every 30 sec").
		- 🎯 Level of Fidelity
			- Consistent Fidelity – Stick to either low-fidelity (basic shapes) or mid-fidelity (more realistic but still grayscale), depending on the stage.
			- No Distractions from UI Design – Keep color, images, and detailed styling minimal or absent to focus on structure.
	- Create Database Design
		- Entities
		- Columns
			- Data type
			- Text
				- Unicode: nchar vs char
				- Variable length: nvarchar vs nchar or varchar vs char
			- Binary Large Object (Blob) Data: binary / varbinary
				- ✅ Store files in the database when:
					- You need atomicity with other data
					- You need central backup and restore simplicity
					- Access control and security are critical
					- You expect relatively small file sizes (e.g., < 1–2 MB)
					- You’re working in a cloud-native / serverless environment
					- Your deployment architecture requires replication and scaling consistency
				- ❌ Avoid storing files in the database when:
					- Files are large or numerous (e.g., media libraries, video uploads)
					- You need high-performance file access or streaming
					- You want to offload storage to a Content Delivery Network (CDN) or object storage like AWS S3, Azure Blob, etc.
				- 📌 Recommendation (Best of Both Worlds):
					- Store metadata and file references in the database (e.g., file name, owner, upload date, and URL)
					- Store the actual files in a dedicated object storage service
			- NULL / NOT NULL
		- Primary key / Composite key / Foreign key
		- Intersection Tables
		- Unique value constraints
		- Indexes
		- ...
	- Create UML Class Diagram
		- Initial: core entities
		- Intermediate: add repositories
		- Intermediate: add services
		- Intermediate: ...
		- Intermediate: ...
		- Final: layered architecture, SOLID
- Learning Outcome 3 - Implementation
	- Explore How Design and Analysis Connect to Implementation
	- Attend Workshops
		- Week 2: Realization and Testing
		- Debugging Essentials in C#: Identifying and Fixing Code Errors
		- How to work with relational databases?
		- How to speed up Web development with ASP.NET and Bootstrap?
		- How to leverage Dependency Injection (DI) with ASP.NET?
		- How to make web application stateful?
	- [Study Basic Web Development (HTML / CSS / JS)](https://www.w3schools.com/html)
		- [HTTP Methods: GET/POST/DELETE/UPDATE](https://www.w3schools.com/TAgs/ref_httpmethods.asp)
		- HTML tags
		- [CSS](https://www.w3schools.com/css) properties, classes
		- Page layout
		- Using forms to capture user data
		- [JavaScript](https://www.w3schools.com/js/js_events.asp) event handling
	- [Study Object Oriented Programming in C#](https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials)
		- Variables
		- Mathematical operations
			- +, -, *
			- division
				- integer (11 / 4 = 2)
				- double (11.0 / 4.0 = 2.75 )
			- modulo
			- [bit operations](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators)
				- Unary bitwise complement
				- Binary left and right shift, unsigned right shift
				- Binary logical AND, OR, and exclusive OR operators
		- String operations
			- Interpolation
			- Trim, TrimStart, TrimEnd
			- Replace
			- Contains
		- Conditional statements
			- if, else, else if
			- switch
		- Collections
			- List types
				- Array
				- ArrayList
				- List\<T\>
				- Queue
				- ConcurrentQueue\<T\>
				- Stack
				- ConcurrentStack\<T\>
				- LinkedList\<T\>
			- Dictionary types
				- Hashtable
				- SortedList
				- SortedList\<TKey,TValue\>
				- Dictionary\<TKey,TValue\>
				- ConcurrentDictionary\<TKey,TValue\>			
		- Loops
			- for
			- while / do while
			- foreach
		- Classes
			- Fields
			- Properties
			- Constructors
			- Methods
			- Access modifiers
			- Constructor / method overloading
			- Encapsulation
		- Visual Studio / JetBrains Rider
			- Solution
			- Project 
			- Dependencies
				- Project reference(s): all public members of the referenced project can be used
				- NuGet packages: libraries from third parties to facilitate faster development
	- Study Building & Using Relational Databases
		- Data Definition Language (DDL): work on the database structure
		- Data Manipulation Language (DML): work with the data in the database
		- Queries
			- SELECT
			- INSERT INTO / UPDATE / DELETE
			- One query statement can contain multiple commands e.g. multiple INSERT statements
		- Aggregate Functions / GROUP BY
		- HAVING clauses
		- Subqueries
		- Join Types
			- Inner join
			- Left outer join
			- Right outer join
			- Full outer join
			- Cross join
		- Database Transactions
	- Study Available Documentation in Canvas
    - Experiment in C#
		- **Only use .NET** project types (not .NET Framework)!
		- Implement relationships between objects
			- Using e.g. a User object reference instead of a UserId
			- Using a List of object references and Add/Remove methods
			- ...
		- Challenges
			- Circus Train
			- Container Transport
			- Visitor Placement Tool
	- Decide on Technology Stack
	- Create Initial Web Application
		- Create initial web application
			- Use the appropriate project type
			- Use .NET version 6, 8, ...  = LTS)
		- Create model classes for your entities
		- Create layout file(s) for structuring your web pages
		- Create the landing page for your project
			- Use model class for binding
			- Hard coded data in code behind (e.g. using a List or Array)
	- Create the Database (Server)
		- Microsoft SQL Server Database server
			- Self-service Portal Fontys ICT
			- Full server installation (Windows)
			- Docker based installation (Windows / Mac / Linux)
		- Create the entities and relationships
		- Import / insert initial data
	- Research Layered Architecture
		- Why Do You Use a Layered Approach?
		- What Should Each Layer Contain?
		- Two Common Variants for Project Dependencies
			- UI ⮕ Core ⮕ Data
			- UI ⮕ Core, UI ⮕ Data and Data ⮕ Core
		- Each Layer is Minimum One C# project
	- Research Data Transfer Objects (DTOs)
		- Data layer: Data transfer
		- UI: View model for binding
		- UI: Request for binding form data & validation
		- UI: Response for returning result of request processing
	- Restructure Initial Application to Match a Layered Architecture
		- Create additional projects (project type: Class Library)
		- Refactor the initial application
			- Move classes to the right layer
			- Rename namespace where needed
			- Introduce new using clauses where needed
	- Implement Application Feature (multiple iterations)
		- Finetune Core Entities When Needed
		- Add Validation Logic
			- Guidelines
				- ✅ Keep validation logic outside the model when it relates to formatting, UI concerns, or request-level data. A domain model should primarily be responsible for business behaviour, not low-level input validation or formatting checks. Keeping these concerns separate leads to more maintainable code. Input validation (e.g., "email must be valid") often belongs in a validator (like a service or external rule set).
				- ✅ Keep validation logic inside the model when it protects domain invariants or governs business behaviour. Business rules (e.g., "You can't cancel a shipped order") belong in the domain model. 
				- 🧠 Think in terms of layers: the model defends the domain, validators defend inputs. 
				- Reusability: Validation rules might be needed in different contexts (e.g., UI, API, command handlers). Keeping validation separate avoids duplication or tight coupling to the entity.
				- Testability: Validation logic is often easier to test in isolation when it's not embedded in a large domain object.
			- As logic in a model class
			- Data Annotations
			- Validator class
			- NuGet: Fluent Validation
			- ...
		- Add Database Interaction
		- Add Application Core Logic
		- Add or finetune UI
	- Research Authentication and Authorization Options
		- ASP.NET Authentication & Claims-based Authorization
		- Using ASP.NET Sessions
		- Custom Middleware
		- ...
	- Implement Authentication and Authorization in Your Application
	- Research Exception Handling Strategies
		- Using custom exceptions
		- Using response classes   
		- NuGet: Fluent Results
		- ...
	- Implement Sound Exception Handling Strategy in Your Application
- Learning Outcome 4 - Managing
	- Explore How Design, Analysis and Implementation Connect to Managing
	- Attend Workshops
		- Week 2: Realization and Testing
		- How to write effective unit tests?
		- How to ensure only the (business) logic is unit tested?
	- Setup Version Control by Creating Git Repository
		- Remote options
			- Preferred: [Gitlab](https://git.fhict.nl)
			- Github
		- Provide access to the repository for your stakeholders (e.g. teachers)
		- Add a relevant .gitignore file
		- Update or add read.me in the repository to reflect your project ideation
		- Create a minimum of two branches
			- Development
			- Production
	- Commit Changes Regularly in Version Control
		- Using feature branches
			- Create feature branch
			- Develop & commit to feature branch
			- Use merge requests to merge feature to Development branch
		- Not Using feature branches
			- Develop
			- Commit changes to your Development branch
		- Use merge request to include all changes in Production branch
	- Define Tests
		- Unit Tests based on Implemented Logic
			- Add a unit test project to your solution
			- Determine mocking strategy
				- Mocking libraries via NuGet
					- Moq
					- NSubstitute
					- FakeItEasy
					- ...
				- Your own mocking classes
			- Determine which code should be unit tested
			- Arrange / Act / Assert
		- Integration Tests based on Database Interaction Logic
			- Random data libraries via NuGet, e.g. Bogus
			- Prepare / Arrange / Act / Assert / Cleanup
		- Acceptance Tests based on Requirements
	- Execute Tests
	- Document Test Results
- Learning Outcome 5 - Professional Standard
	- Establish Project Planning
		- Research Potential Options to Keep Track of Your Progress
		- Decide on Progress Tracker
			- Task Lists
			- Kanban Views
				- GitLab / Github Boards
				- Trello
				- Asana
			- ...
		- Initiate the Tracker with Milestones for Your Project
			- Based on Project Plan
			- Add High Level Milestones 
				- Analysis
				- Design
				- Realisation / Implementation
				- Validation
		- Assign Rough Time Estimates to Milestones
	- Track Project Progress (multiple iterations)
		- Refine your Planning with Acquired Insights
			- Must Have Requirements and Use Cases
			- MoSCoW
			- Wireframes
			- Web Site Design 
			- ...
		- Assign Rough Time Estimates to Activities
		- Assess How You're Doing versus Project Goal
			- On Track: Keep going 
			- Ahead of Schedule: Add Should Have and/or Could Have requirements
			- Off Track: Reflect on progress made
				- Consider options to speed up
				- Reduce the scope (discuss with your stakeholders)
	- Track Progress in Portfolio
		- Describe the activities you did
			- What did you do?
			- Why did you do that?
			- 
		- Include validated evidence
			- Analysis documents
			- Design documents
			- Documents containing code snippets
				- Include explanatory text why a snippet is relevant
			- Progress tracking
			- ...